home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / xwindows / demos / xfract_1.z / xfract_1 / xfractint-1.06 / unix.c < prev    next >
C/C++ Source or Header  |  1992-09-28  |  7KB  |  397 lines
  1. /* Unix.c
  2.  * This file contains compatibility routines.
  3.  *
  4.  * This file Copyright 1991 Ken Shirriff.  It may be used according to the
  5.  * fractint license conditions, blah blah blah.
  6.  */
  7.  
  8. #include <stdio.h>
  9. #include <sys/time.h>
  10. #include <sys/types.h>
  11. #include <sys/stat.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include "port.h"
  15.  
  16. int iocount;
  17.  
  18. /*
  19.  *----------------------------------------------------------------------
  20.  *
  21.  * clock_ticks --
  22.  *
  23.  *      Return time in CLK_TCK ticks.
  24.  *
  25.  * Results:
  26.  *      Time.
  27.  *
  28.  * Side effects:
  29.  *      None.
  30.  *
  31.  *----------------------------------------------------------------------
  32.  */
  33. long
  34. clock_ticks()
  35. {
  36.     struct timeval tim;
  37.     gettimeofday(&tim,NULL);
  38.     return tim.tv_sec*CLK_TCK + tim.tv_usec*CLK_TCK/1000000;
  39. }
  40.  
  41. /* stub */
  42. intdos() {}
  43.  
  44. /*
  45.  *----------------------------------------------------------------------
  46.  *
  47.  * kbhit --
  48.  *
  49.  *      Get a key.
  50.  *
  51.  * Results:
  52.  *      1 if key, 0 otherwise.
  53.  *
  54.  * Side effects:
  55.  *      None.
  56.  *
  57.  *----------------------------------------------------------------------
  58.  */
  59. int
  60. kbhit()
  61. {
  62.     return 0;
  63. }
  64.  
  65. /*
  66.  *----------------------------------------------------------------------
  67.  *
  68.  * stackavail --
  69.  *
  70.  *      Returns amout of stack available.
  71.  *
  72.  * Results:
  73.  *      Available stack.
  74.  *
  75.  * Side effects:
  76.  *      None.
  77.  *
  78.  *----------------------------------------------------------------------
  79.  */
  80. long
  81. stackavail()
  82. {
  83.     return 8192;
  84. }
  85.  
  86. #ifndef HAVESTRI
  87. /*
  88.  *----------------------------------------------------------------------
  89.  *
  90.  * stricmp --
  91.  *
  92.  *      Compare strings, ignoring case.
  93.  *
  94.  * Results:
  95.  *      -1,0,1.
  96.  *
  97.  * Side effects:
  98.  *      None.
  99.  *
  100.  *----------------------------------------------------------------------
  101.  */
  102. stricmp(s1, s2)
  103.     register char *s1, *s2;        /* Strings to compare. */
  104. {
  105.     int c1, c2;
  106.  
  107.     while (1) {
  108.     c1 = *s1++;
  109.     c2 = *s2++;
  110.     if (isupper(c1)) c1 = tolower(c1);
  111.     if (isupper(c2)) c2 = tolower(c2);
  112.     if (c1 != c2) {
  113.         return c1 - c2;
  114.     }
  115.     if (c1 == 0) {
  116.         return 0;
  117.     }
  118.     }
  119. }
  120. /*
  121.  *----------------------------------------------------------------------
  122.  *
  123.  * strnicmp --
  124.  *
  125.  *      Compare strings, ignoring case.  Maximum length is specified.
  126.  *
  127.  * Results:
  128.  *      -1,0,1.
  129.  *
  130.  * Side effects:
  131.  *      None.
  132.  *
  133.  *----------------------------------------------------------------------
  134.  */
  135. int
  136. strnicmp(s1, s2, numChars)
  137.     register char *s1, *s2;        /* Strings to compare. */
  138.     register int numChars;        /* Max number of chars to compare. */
  139. {
  140.     register char c1, c2;
  141.  
  142.     for ( ; numChars > 0; --numChars) {
  143.     c1 = *s1++;
  144.     c2 = *s2++;
  145.     if (isupper(c1)) c1 = tolower(c1);
  146.     if (isupper(c2)) c2 = tolower(c2);
  147.     if (c1 != c2) {
  148.         return c1 - c2;
  149.     }
  150.     if (c1 == '\0') {
  151.         return 0;
  152.     }
  153.     }
  154.     return 0;
  155. }
  156. #endif
  157.  
  158. /*
  159.  *----------------------------------------------------------------------
  160.  *
  161.  * strlwr --
  162.  *
  163.  *      Convert string to lower case.
  164.  *
  165.  * Results:
  166.  *      The string.
  167.  *
  168.  * Side effects:
  169.  *      Modifies the string.
  170.  *
  171.  *----------------------------------------------------------------------
  172.  */
  173. char *
  174. strlwr(s)
  175.     char *s;
  176. {
  177.     register char *sptr=s;
  178.     while (*sptr != '\0') {
  179.     if (isupper(*sptr)) {
  180.         *sptr = tolower(*sptr);
  181.     }
  182.     sptr++;
  183.     }
  184.     return s;
  185. }
  186. /*
  187.  *----------------------------------------------------------------------
  188.  *
  189.  * strupr --
  190.  *
  191.  *      Convert string to upper case.
  192.  *
  193.  * Results:
  194.  *      The string.
  195.  *
  196.  * Side effects:
  197.  *      Modifies the string.
  198.  *
  199.  *----------------------------------------------------------------------
  200.  */
  201. char *
  202. strupr(s)
  203.     char *s;
  204. {
  205.     register char *sptr=s;
  206.     while (*sptr != '\0') {
  207.     if (islower(*sptr)) {
  208.         *sptr = toupper(*sptr);
  209.     }
  210.     sptr++;
  211.     }
  212.     return s;
  213. }
  214. /*
  215.  *----------------------------------------------------------------------
  216.  *
  217.  * memicmp --
  218.  *
  219.  *      Compare memory (like memcmp), but ignoring case.
  220.  *
  221.  * Results:
  222.  *      -1,0,1.
  223.  *
  224.  * Side effects:
  225.  *      None.
  226.  *
  227.  *----------------------------------------------------------------------
  228.  */
  229. int
  230. memicmp(s1, s2, n)
  231.         register char *s1, *s2;
  232.         register n;
  233. {
  234.         register char c1,c2;
  235.         while (--n >= 0)
  236.         c1 = *s1++;
  237.         if (isupper(c1)) c1 = tolower(c1);
  238.         c2 = *s2++;
  239.         if (isupper(c2)) c2 = tolower(c2);
  240.                 if (c1 != c2)
  241.                         return (c1 - c2);
  242.         return (0);
  243. }
  244.  
  245. /*
  246.  *----------------------------------------------------------------------
  247.  *
  248.  * findpath --
  249.  *
  250.  *      Find where a file is.
  251.  *    We return filename if it is an absolute path.
  252.  *    Otherwise we return SRCDIR/filename.
  253.  *
  254.  * Results:
  255.  *      Returns full pathname in fullpathname.
  256.  *
  257.  * Side effects:
  258.  *      None.
  259.  *
  260.  *----------------------------------------------------------------------
  261.  */
  262. void
  263. findpath(filename, fullpathname)
  264. char *filename, *fullpathname;
  265. {
  266.     if (filename[0]=='/') {
  267.     strcpy(fullpathname,filename);
  268.     return;
  269.     }
  270.     strcpy(fullpathname,SRCDIR);
  271.     strcat(fullpathname,"/");
  272.     strcat(fullpathname,filename);
  273. }
  274.  
  275. /*
  276.  *----------------------------------------------------------------------
  277.  *
  278.  * filelength --
  279.  *
  280.  *      Find length of a file.
  281.  *
  282.  * Results:
  283.  *      Length.
  284.  *
  285.  * Side effects:
  286.  *      None.
  287.  *
  288.  *----------------------------------------------------------------------
  289.  */
  290. int filelength(fd)
  291. int fd;
  292. {
  293.     struct stat buf;
  294.     fstat(fd,&buf);
  295.     return buf.st_size;
  296. }
  297.  
  298. /*
  299.  *----------------------------------------------------------------------
  300.  *
  301.  * splitpath --
  302.  *
  303.  *      This is the splitpath code from prompts.c
  304.  *
  305.  * Results:
  306.  *      Returns drive, dir, base, and extension.
  307.  *
  308.  * Side effects:
  309.  *      None.
  310.  *
  311.  *----------------------------------------------------------------------
  312.  */
  313. splitpath(char *template,char *drive,char *dir,char *fname,char *ext)
  314. {
  315.    int length;
  316.    int len;
  317.    int offset;
  318.    char *tmp;
  319.  
  320.    if(drive)
  321.       drive[0] = 0;
  322.    if(dir)
  323.       dir[0]   = 0;
  324.    if(fname)
  325.       fname[0] = 0;
  326.    if(ext)
  327.       ext[0]   = 0;
  328.  
  329.    if((length = strlen(template)) == 0)
  330.       return(0);
  331.    offset = 0;
  332.  
  333.    /* get drive */
  334.    if(length >= 2)
  335.       if(template[1] == ':')
  336.       {
  337.      if(drive)
  338.      {
  339.         drive[0] = template[offset++];
  340.         drive[1] = template[offset++];
  341.         drive[2] = 0;
  342.      }
  343.      else
  344.      {
  345.         offset++;
  346.         offset++;
  347.      }
  348.       }
  349.  
  350.    /* get dir */
  351.    if(offset < length)
  352.    {
  353.       tmp = strrchr(template,SLASHC);
  354.       if(tmp)
  355.       {
  356.      tmp++;  /* first character after slash */
  357.      len = tmp - &template[offset];
  358.      if(len >=0 && len < 80 && dir)
  359.         strncpy(dir,&template[offset],len);
  360.      if(len < 80 && dir)
  361.         dir[len] = 0;
  362.      offset += len;
  363.       }
  364.    }
  365.    else
  366.       return(0);
  367.  
  368.    /* get fname */
  369.    if(offset < length)
  370.    {
  371.       tmp = strrchr(template,'.');
  372.       if(tmp < strrchr(template,SLASHC) || tmp < strrchr(template,':'))
  373.      tmp = 0; /* in this case the '.' must be a directory */
  374.       if(tmp)
  375.       {
  376.      tmp++; /* first character past "." */
  377.      len = tmp - &template[offset];
  378.      if((len > 0) && (offset+len < length) && fname)
  379.      {
  380.         strncpy(fname,&template[offset],len);
  381.         fname[len] = 0;
  382.      }
  383.      offset += len;
  384.      if((offset < length) && ext)
  385.         strcpy(ext,&template[offset]);
  386.       }
  387.       else if((offset < length) && fname)
  388.      strcpy(fname,&template[offset]);
  389.    }
  390.    return(0);
  391. }
  392.  
  393. _splitpath(char *template,char *drive,char *dir,char *fname,char *ext)
  394. {
  395.     return splitpath(template,drive,dir,fname,ext);
  396. }
  397.